package com.sheng.leetcode.year2023.month11.day22;

import org.junit.Test;

/**
 * @author by ls
 * @date 2023/11/22
 * <p>
 * 2304. 网格中的最小路径代价<p>
 * <p>
 * 给你一个下标从 0 开始的整数矩阵 grid ，矩阵大小为 m x n ，由从 0 到 m * n - 1 的不同整数组成。<p>
 * 你可以在此矩阵中，从一个单元格移动到 下一行 的任何其他单元格。如果你位于单元格 (x, y) ，<p>
 * 且满足 x < m - 1 ，你可以移动到 (x + 1, 0), (x + 1, 1), ..., (x + 1, n - 1)<p>
 * 中的任何一个单元格。注意： 在最后一行中的单元格不能触发移动。<p>
 * 每次可能的移动都需要付出对应的代价，代价用一个下标从 0 开始的二维数组 moveCost 表示，<p>
 * 该数组大小为 (m * n) x n ，其中 moveCost[i][j] 是从值为 i 的单元格移动到<p>
 * 下一行第 j 列单元格的代价。从 grid 最后一行的单元格移动的代价可以忽略。<p>
 * grid 一条路径的代价是：所有路径经过的单元格的 值之和 加上 所有移动的 代价之和 。<p>
 * 从 第一行 任意单元格出发，返回到达 最后一行 任意单元格的最小路径代价。<p>
 * <p>
 * 示例 1：<p>
 * 输入：grid = [[5,3],[4,0],[2,1]], moveCost = [[9,8],[1,5],[10,12],[18,6],[2,4],[14,3]]<p>
 * 输出：17<p>
 * 解释：最小代价的路径是 5 -> 0 -> 1 。<p>
 * - 路径途经单元格值之和 5 + 0 + 1 = 6 。<p>
 * - 从 5 移动到 0 的代价为 3 。<p>
 * - 从 0 移动到 1 的代价为 8 。<p>
 * 路径总代价为 6 + 3 + 8 = 17 。<p>
 * <p>
 * 示例 2：<p>
 * 输入：grid = [[5,1,2],[4,0,3]], moveCost = [[12,10,15],[20,23,8],[21,7,1],[8,1,13],[9,10,25],[5,3,2]]<p>
 * 输出：6<p>
 * 解释：<p>
 * 最小代价的路径是 2 -> 3 。<p>
 * - 路径途经单元格值之和 2 + 3 = 5 。<p>
 * - 从 2 移动到 3 的代价为 1 。<p>
 * 路径总代价为 5 + 1 = 6 。<p>
 * <p>
 * 提示：<p>
 * m == grid.length<p>
 * n == grid[i].length<p>
 * 2 <= m, n <= 50<p>
 * grid 由从 0 到 m * n - 1 的不同整数组成<p>
 * moveCost.length == m * n<p>
 * moveCost[i].length == n<p>
 * 1 <= moveCost[i][j] <= 100<p>
 */
public class LeetCode2304 {

    @Test
    public void test01() {
        int[][] grid = {{5, 3}, {4, 0}, {2, 1}}, moveCost = {{9, 8}, {1, 5}, {10, 12}, {18, 6}, {2, 4}, {14, 3}};
//        int[][] grid = {{5, 1, 2}, {4, 0, 3}}, moveCost = {{12, 10, 15}, {20, 23, 8}, {21, 7, 1}, {8, 1, 13}, {9, 10, 25}, {5, 3, 2}};
        System.out.println(new Solution().minPathCost(grid, moveCost));
    }
}

class Solution {

    int m, n, ans = Integer.MAX_VALUE;

    int[][] grid, moveCost, nums;

    public int minPathCost(int[][] grid, int[][] moveCost) {
        // 对于 (x, y) 如果 x 不是最后一个元素，那么它可以移动到下一行的任意一个节点
        m = grid.length;
        n = grid[0].length;
        nums = new int[m][n];
        this.grid = grid;
        this.moveCost = moveCost;
        // 从头开始往下走
        for (int i = 0; i < n; i++) {
            ans = Math.min(ans, dfs(0, i));
        }
        return ans;
    }

    public int dfs(int x, int y) {
        if (x == m - 1) {
            // 已抵达最后一行
            return grid[x][y];
        }
        // 记忆化搜索
        if (nums[x][y] != 0) {
            return nums[x][y];
        }
        // 继续循环
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            ans = Math.min(ans, dfs(x + 1, i) + moveCost[grid[x][y]][i]);
        }
        // 作记录
        return nums[x][y] = ans + grid[x][y];
    }
}
